package cn.ondraw.ragflow.controller;

import cn.ondraw.ragflow.pojo.request.*;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import cn.ondraw.common.core.domain.R;
import cn.ondraw.ragflow.pojo.request.*;
import cn.ondraw.ragflow.pojo.request.*;
import cn.ondraw.ragflow.service.RagFlowCanvasService;
import org.springframework.web.bind.annotation.*;

/**
 * 画布控制器，处理与画布相关的接口请求
 */
@RestController
@Slf4j
@RequiredArgsConstructor
@RequestMapping("/v1/canvas")
public class RagFlowCanvasController {
    private final RagFlowCanvasService ragFlowCanvasService;

    /**
     * 获取画布模板列表
     *
     * @return 通用响应对象，包含画布模板列表数据
     */
    @GetMapping("/templates")
    public R<Object> templates() {
        return R.ok(ragFlowCanvasService.templates());
    }

    /**
     * 获取画布列表
     *
     * @return 通用响应对象，包含画布列表数据
     */
    @GetMapping("/list")
    public R<Object> canvasList() {
        return R.ok(ragFlowCanvasService.canvasList());
    }

    /**
     * 删除画布
     *
     * @param request 删除画布请求对象
     * @return 通用响应对象，包含删除操作结果数据
     */
    @PostMapping("/rm")
    public R<Object> rm(@RequestBody CanvasRmRequest request) {
        return R.ok(ragFlowCanvasService.rm(request));
    }

    /**
     * 保存画布设置
     *
     * @param request 保存画布请求对象
     * @return 通用响应对象，包含保存操作结果数据
     */
    @PostMapping("/set")
    public R<Object> save(@RequestBody SetRequest request) {
        return R.ok(ragFlowCanvasService.save(request));
    }

    /**
     * 根据画布 ID 获取画布信息
     *
     * @param canvasId 画布 ID
     * @return 通用响应对象，包含指定画布信息数据
     */
    @GetMapping("/get/{canvasId}")
    public R<Object> get(@PathVariable String canvasId) {
        return R.ok(ragFlowCanvasService.get(canvasId));
    }

    /**
     * 根据画布 ID 获取服务器端事件流数据
     *
     * @param canvasId 画布 ID
     * @param token    授权令牌
     * @return 通用响应对象，包含服务器端事件流数据
     */
    @GetMapping("/getsse/{canvasId}")
    public R<Object> getsse(@PathVariable String canvasId, @RequestHeader("Authorization") String token) {
        return R.ok(ragFlowCanvasService.getsse(canvasId, token.split(" ")[1]));
    }

    /**
     * 执行画布完成操作
     *
     * @param request 完成操作请求对象
     * @return 通用响应对象，包含完成操作结果数据
     */
    @PostMapping("/completion")
    public R<Object> completion(@RequestBody CompletionRequest request) {
        try {

            return R.ok(ragFlowCanvasService.completion(request));
        } catch (Exception e) {
            return R.fail(e.getMessage());
        }
    }

    /**
     * 重置画布
     *
     * @param request 重置画布请求对象
     * @return 通用响应对象，包含重置操作结果数据
     */
    @PostMapping("/reset")
    public R<Object> reset(@RequestBody ResetRequest request) {
        try {
            return R.ok(ragFlowCanvasService.reset(request));
        } catch (Exception e) {
            return R.fail(e.getMessage());
        }
    }

    /**
     * 获取画布输入元素信息
     *
     * @param id           画布 ID
     * @param component_id 组件 ID
     * @return 通用响应对象，包含画布输入元素信息数据
     */
    @GetMapping("/input_elements")
    public R<Object> inputElements(@RequestParam String id, @RequestParam String component_id) {
        try {
            InputElementsRequest request = new InputElementsRequest();
            request.setCvs_id(id);
            request.setCpn_id(component_id);
            return R.ok(ragFlowCanvasService.inputElements(request));
        } catch (Exception e) {
            return R.fail(e.getMessage());
        }
    }

    /**
     * 调试画布
     *
     * @param request 调试请求对象
     * @return 通用响应对象，包含调试操作结果数据
     */
    @PostMapping("/debug")
    public R<Object> debug(@RequestBody DebugRequest request) {
        try {
            return R.ok(ragFlowCanvasService.debug(request));
        } catch (Exception e) {
            return R.fail(e.getMessage());
        }
    }

    /**
     * 测试数据库连接
     *
     * @param request 测试数据库连接请求对象
     * @return 通用响应对象，包含测试数据库连接结果数据
     */
    @PostMapping("/test_db_connect")
    public R<Object> testDbConnect(@RequestBody TestDbConnectRequest request) {
        try {
            return R.ok(ragFlowCanvasService.testDbConnect(request));
        } catch (Exception e) {
            return R.fail(e.getMessage());
        }
    }

    /**
     * 根据画布 ID 获取画布版本列表
     *
     * @param canvasId 画布 ID
     * @return 通用响应对象，包含画布版本列表数据
     */
    @GetMapping("/getlistversion/{canvasId}")
    public R<Object> getlistversion(@PathVariable String canvasId) {
        try {
            return R.ok(ragFlowCanvasService.getlistversion(canvasId));
        } catch (Exception e) {
            return R.fail(e.getMessage());
        }
    }

    /**
     * 根据版本 ID 获取画布版本信息
     *
     * @param versionId 版本 ID
     * @return 通用响应对象，包含指定画布版本信息数据
     */
    @GetMapping("/getversion/{versionId}")
    public R<Object> getversion(@PathVariable String versionId) {
        try {
            return R.ok(ragFlowCanvasService.getversion(versionId));
        } catch (Exception e) {
            return R.fail(e.getMessage());
        }
    }

    /**
     * 获取团队知识库列表
     *
     * @param keywords  搜索关键词，默认值为空
     * @param page      页码，默认值为 1
     * @param page_size 每页数量，默认值为 150
     * @param orderby   排序字段，默认值为 "create_time"
     * @param desc      是否降序排序，默认值为 true
     * @return 通用响应对象，包含团队知识库列表数据
     */
    @GetMapping("/listteam")
    public R<Object> list_kbs(@RequestParam(defaultValue = "") String keywords,
                              @RequestParam(defaultValue = "1") int page,
                              @RequestParam(defaultValue = "150") int page_size,
                              @RequestParam(defaultValue = "create_time") String orderby,
                              @RequestParam(defaultValue = "true") boolean desc) {
        try {
            ListTeamRequest request = new ListTeamRequest();
            request.setKeywords(keywords);
            request.setPage_number(page);
            request.setItems_per_page(page_size);
            request.setOrderby(orderby);
            request.setDesc(desc);
            return R.ok(ragFlowCanvasService.list_kbs(request));
        } catch (Exception e) {
            return R.fail(e.getMessage());
        }
    }

    /**
     * 设置画布信息
     *
     * @param request 设置请求对象
     * @return 通用响应对象，包含设置操作结果数据
     */
    @PostMapping("/setting")
    public R<Object> setting(@RequestBody SettingRequest request) {
        try {
            return R.ok(ragFlowCanvasService.setting(request));
        } catch (Exception e) {
            return R.fail(e.getMessage());
        }
    }
}
